home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Text⁄Files / Writeswell Jr. 1.0.2 Master / Writeswell Jr. Source / TestBed.c < prev    next >
C/C++ Source or Header  |  1992-12-30  |  16KB  |  809 lines
  1. /* TestBed.c
  2.  * Word Services Testbed - main module for Writeswell Jr.
  3.  *
  4.  * ©1992 Working Software, Inc.
  5.  * This source code is copyrighted.  Permission is granted to use the Word Services
  6.  * portion of the Writeswell Jr. source code in your own programs, but you 
  7.  * may not distribute the Writeswell Jr. word-processor code as a 
  8.  * commercial product.  If you modify the code, please do not call it 
  9.  * Writeswell Jr. (or Writeswell.)  This will ensure that people understand the 
  10.  * program and don’t have to deal with a number of different versions with 
  11.  * who-knows-what going on in the code.
  12.  * 
  13.  * Writeswell Jr. and Writeswell are trademarks of Working Software, Inc.
  14. */
  15.  
  16. #include <EPPC.h>
  17. #include <AppleEvents.h>
  18. #include <AEObjects.h>
  19. #include <Printing.h>
  20. #include "AERegistry.h"
  21. #include "WordServices.h"
  22. #include "TestBed.h"
  23. #include "TBConstants.h"
  24. #include "MyFiles.h"
  25. #include "GenHandlers.h"
  26. #include "AppEvents.h"
  27. #include "AEObj.h"
  28. #include "InitMenu.h"
  29. #include "Gripe.h"
  30. #include "Scroll.h"
  31. #include "Prefs.h"
  32. #include "DoChecking.h"
  33. #include "ServiceMgr.h"
  34. #include "ObWind.h"
  35. #include "ObText.h"
  36. #include "ObNull.h"
  37. #include "FontMenu.h"
  38. #include "Options.h"
  39. #include "ServiceDialog.h"
  40. #include "PrintWWJr.h"
  41. #include "UnloadStuff.h"
  42. #include "InitWWJr.h"
  43. #include "MyGestalt.h"
  44. #include "PageSetup.h"
  45.  
  46. #define GLOBALS_HERE
  47. #include "TBGlobals.h"
  48. #undef GLOBALS_HERE
  49.  
  50. Boolean DoMouseDown( EventRecord *eventPtr );
  51. Boolean DoMenuCommand( long menuSpot );
  52. Boolean DoAppleMenu( short theItem );
  53. Boolean DoFileMenu( short theItem );
  54. Boolean DoEditMenu( short theItem );
  55. Boolean DoServMenu( short theItem );
  56. Boolean DoKeyDown( long message, short modifiers );
  57. Boolean DoActivateEvt( short modifiers );
  58. Boolean DoUpdateEvt( long message );
  59. void DoAboutMe( void );
  60. Boolean DoOSEvt( EventRecord *eventPtr );
  61. void GrowDocWindow( WindowPtr theWindow, Point where );
  62. void SetTESize( WindowPtr theWindow );
  63. void MyDrawGrowIcon( WindowPtr theWindow );
  64. void DoCloseWindow( void );
  65. Boolean AskSave( void );
  66. void DoQuit( void );
  67. void DoZoom( WindowPtr theWindow, short deskPart );
  68. void ResetWindowParts( WindowPtr theWindow );
  69. pascal void AboutVersionProc( DialogPtr dlg, short item );
  70.  
  71. void main( void )
  72. {
  73.     short foo;
  74.     OSErr    err;
  75.  
  76.     MaxApplZone();
  77.     InitGraf(&thePort);
  78.     InitFonts();
  79.     /* FlushEvents(everyEvent, 0); */
  80.     InitWindows();
  81.     TEInit();
  82.     InitDialogs(0L);
  83.     
  84.     gDocDirty = false;
  85.  
  86.     gAppFileRefNum = CurResFile();
  87.  
  88.     gQuitRequested = false;
  89.     gPrintRequested = false;
  90.  
  91.     if ( !OpenPrefFile() ){
  92.         Gripe( "\pCannot open Writeswell, Jr. Preferences" );
  93.         ExitToShell();
  94.     }
  95.  
  96.     InitCursor();
  97.  
  98.     if ( System7Installed() ){
  99.         err = InitForSystem7();
  100.     }else{
  101.         err = InitForSystem6();
  102.     }
  103.  
  104.     if ( err )
  105.         ExitToShell();
  106.  
  107.     while ( EventLoop() )
  108.         ;
  109. }
  110.  
  111. Boolean EventLoop( void )
  112. {
  113.     EventRecord theEvent;
  114.     
  115.     UnloadStuff();
  116.  
  117.     if ( gPrintRequested ){
  118.         gPrintRequested = false;
  119.         DoPrint();
  120.     }
  121.  
  122.     if ( gQuitRequested ){
  123.         DoQuit();
  124.         return false;            /* We should never reach this statement */
  125.     }
  126.  
  127.     WaitNextEvent( everyEvent, &theEvent, 30, (RgnHandle)NULL );
  128.     
  129.  
  130.     if ( gDocWindow )
  131.         TEIdle( (TEHandle)GetWRefCon( gDocWindow ) );
  132.     
  133.     switch( theEvent.what ){
  134.         case nullEvent:
  135.             DoNullEvent( &theEvent );
  136.             break;
  137.         case mouseDown:
  138.             return DoMouseDown( &theEvent );
  139.             break;
  140.         case mouseUp:
  141.             DoMouseUp();
  142.             break;
  143.         case autoKey:
  144.         case keyDown:
  145.             return DoKeyDown( theEvent.message, theEvent.modifiers );
  146.             break;
  147.         case updateEvt:
  148.             DoUpdateEvt( theEvent.message );
  149.             break;
  150.         case diskEvt:
  151.             DoDiskEvt();
  152.             break;
  153.         case activateEvt:
  154.             DoActivateEvt( theEvent.modifiers );
  155.             break;
  156.         case osEvt:
  157.             DoOSEvt( &theEvent );
  158.             break;
  159.         case kHighLevelEvent:
  160.             DoHighLevelEvent( &theEvent );
  161.             break;
  162.         default:
  163.             /*Gripe("\pGot unknown event type" );*/
  164.             break;    
  165.     }
  166.  
  167.     return true;
  168. }
  169.  
  170. Boolean DoNullEvent( EventRecord *theEventPtr )
  171. {
  172.     /* One could execute some sort of background task here */
  173.  
  174.     return true;
  175. }
  176.  
  177. Boolean DoMouseDown( EventRecord *eventPtr )
  178. {
  179.     WindowPtr    theWindow;
  180.     Boolean        result = true;
  181.     Rect        dragRect;
  182.     TEHandle    textH;
  183.     short        partCode;
  184.     ControlHandle    ctlHdl;
  185.     short        curFile;
  186.     short        deskPart;
  187.     
  188.     deskPart = FindWindow( eventPtr->where, &theWindow );
  189.     switch( deskPart ){
  190.         case inDesk:
  191.             break;
  192.         case inMenuBar:
  193.             FixMenuMarks();
  194.             curFile = CurResFile();
  195.             UseResFile( gPrefFileRefNum );        /* Make SICN resource accessible */
  196.             result = DoMenuCommand( MenuSelect( eventPtr->where ) );
  197.             UseResFile( curFile );
  198.             FixMenuMarks();
  199.             break;
  200.         case inSysWindow:
  201.             SystemClick( eventPtr, theWindow );
  202.             break;
  203.         case inContent:
  204.             if ( theWindow != FrontWindow() ){
  205.                 SelectWindow( theWindow );
  206.             } else {
  207.                 GlobalToLocal( &(eventPtr->where) );
  208.                 partCode = FindControl( eventPtr->where, theWindow, &ctlHdl );
  209.                 if ( partCode == 0 ){
  210.                     textH = (TEHandle)GetWRefCon( theWindow );
  211.                     
  212.                     gScrollWindow = theWindow;        /* For use by TrackContentClick */
  213.  
  214.                     TEClick( eventPtr->where, eventPtr->modifiers & shiftKey, textH );
  215.                 }else{
  216.                     DoControl( theWindow, ctlHdl, partCode, eventPtr->where );
  217.                 }
  218.             }
  219.             break;
  220.         case inDrag:
  221.             DragWindow( theWindow, eventPtr->where, &screenBits.bounds );    /* NOT correct but works */
  222.             break;
  223.         case inGrow:
  224.             GrowDocWindow( theWindow, eventPtr->where );
  225.             break;
  226.         case inGoAway:
  227.             if ( TrackGoAway( theWindow, eventPtr->where ))
  228.                 DoCloseWindow();
  229.             break;
  230.         case inZoomIn:
  231.         case inZoomOut:
  232.             if ( TrackBox( theWindow, eventPtr->where, deskPart ) )
  233.                 DoZoom( theWindow, deskPart );
  234.             break;
  235.     }
  236.     return result;
  237. }
  238.  
  239. void DoCloseWindow( void )
  240. {
  241.     Boolean saveIt;
  242.     
  243.     if ( gDocDirty ){
  244.         saveIt = AskSave();
  245.         if ( saveIt )
  246.             DoSave();
  247.     }
  248.  
  249.     TEDispose( (TEHandle)GetWRefCon( gDocWindow) );
  250.     DisposeWindow( gDocWindow );        
  251.     gDocWindow = (WindowPtr)NULL;
  252.     
  253.     if ( gDocExists ){
  254.         /* If the file exists on disk, close it */
  255.         FSClose( gRefNum );
  256.         if ( gResRefNum != -1 )
  257.             CloseResFile( gResRefNum );
  258.     }
  259.  
  260.     FixMenuMarks();            /* Disable menu items to reflect absent window */
  261.  
  262.     return;
  263. }
  264.  
  265. Boolean AskSave( void )
  266. {
  267.     short    item;
  268.     
  269.     item = Alert( rAskSaveID, (ProcPtr)NULL );
  270.  
  271.     if ( item == kASSave )
  272.         return true;
  273.     
  274.     return false;
  275. }
  276.  
  277. Boolean DoMenuCommand( long menuSpot )
  278. {
  279.     short theMenu;
  280.     short theItem;
  281.     Boolean result;
  282.         
  283.     theMenu = HiWord( menuSpot );
  284.     
  285.     theItem = LoWord( menuSpot );
  286.     
  287.     switch ( theMenu ){
  288.         case 0:
  289.             result = true;
  290.             break;
  291.         case kAppleMenuID:
  292.             result = DoAppleMenu( theItem );
  293.             break;
  294.         case kFileMenuID:
  295.             result = DoFileMenu( theItem );
  296.             break;
  297.         case kEditMenuID:
  298.             result = DoEditMenu( theItem );
  299.             break;
  300.         case kFontMenuID:
  301.             result = DoFontMenu( theItem );
  302.             break;
  303.         case kStyleMenuID:
  304.             result = DoStyleMenu( theItem );
  305.             break;
  306.         case kServMenuID:
  307.             result = DoServMenu( theItem );
  308.             break;
  309.     }
  310.     
  311.     HiliteMenu( 0 );
  312.     return result;
  313. }
  314.  
  315. Boolean DoAppleMenu( short theItem )
  316. {
  317.     Handle appleHandle;
  318.     Str255 itemName;
  319.     
  320.     switch ( theItem ){
  321.         case kAMAboutMe:
  322.             DoAboutMe();
  323.             break;
  324.         case kAMDash:
  325.             break;
  326.         default:
  327.             appleHandle = GetResource( 'MENU', kAppleMenuID );
  328.             if ( !appleHandle ){
  329.                 Gripe( "\pCannot get handle to apple menu" );
  330.                 return false;
  331.             }
  332.             
  333.             GetItem( appleHandle, theItem, itemName );
  334.             OpenDeskAcc( itemName );
  335.             if ( gDocWindow ){
  336.                 SetPort( gDocWindow );
  337.             }
  338.             break;
  339.     }
  340.     return true;
  341. }
  342.  
  343. Boolean DoFileMenu( short theItem )
  344. {
  345.     switch ( theItem ){
  346.         case kFMNew:
  347.             if ( gDocWindow )
  348.                 return true;
  349.             
  350.             return MakeNewWindow() == noErr;
  351.             break;
  352.         case kFMOpen:
  353.             DoOpenDialog();
  354.             break;
  355.         case kFMClose:
  356.             DoCloseWindow();
  357.             break;
  358.         case kFMSave:
  359.             DoSave();
  360.             break;
  361.         case kFMSaveAs:
  362.             DoSaveDialog();
  363.             break;
  364.         case kFMPageSetup:
  365.             DoPageSetup();
  366.             break;
  367.         case kFMPrint:
  368.             DoPrint();
  369.             break;
  370.         case kFMQuit:
  371.             DoQuit();
  372.             break;
  373.     }
  374.     
  375.     return true;
  376. }
  377.  
  378. Boolean DoEditMenu( short theItem )
  379. {
  380.     TEHandle textH;
  381.  
  382.     if ( !SystemEdit( theItem - 1 ) ){
  383.         if ( gDocWindow ){
  384.             textH = (TEHandle)GetWRefCon( gDocWindow );
  385.             
  386.             switch( theItem ){
  387.                 case kEMCut:
  388.                     gDocDirty = true;
  389.                     TECut( textH );
  390.                     break;
  391.                 case kEMCopy:
  392.                     TECopy( textH );
  393.                     break;
  394.                 case kEMPaste:
  395.                     gDocDirty = true;
  396.                     TEStylPaste( textH );
  397.                     break;
  398.                 case kEMClear:
  399.                     gDocDirty = true;
  400.                     TEDelete( textH );
  401.                     break;
  402.                 case kEMOptions:
  403.                     OptionsDialog();
  404.                     break;
  405.             }
  406.             
  407.             SetVertScroll( gDocWindow, gVertScroll );
  408.         }else{
  409.             /* Handle the operations that we can do while the window is closed */
  410.             switch( theItem ){
  411.                 case kEMOptions:
  412.                     OptionsDialog();
  413.                     break;
  414.             }
  415.         
  416.         }
  417.     }
  418.     return true;
  419. }
  420.  
  421. Boolean DoServMenu( short theItem )
  422. {
  423.     OSErr err;
  424.  
  425.     switch( theItem ){
  426. #ifdef NEVER                /* This will return in a future version */
  427.         case kSMCheckSel:
  428.             ToggleSelectCheck();
  429.             break;
  430. #endif
  431.         case kSMNewBatch:
  432.             err = GetNewBatchService();
  433.             if ( err )
  434.                 Gripe( "\pGetNewBatchService failed" );
  435.             break;
  436. #ifdef NEVER                /* This will return in a future version */
  437.         case kSMNewInteractive:
  438.             if ( !gDocWindow )
  439.                 return true;
  440.             break;
  441. #endif
  442.         case kSMRemoveService:
  443.             RemoveServices();
  444.             break;
  445. #ifdef NEVER                /* This will return in a future version */
  446.         case kSMCheckWord:
  447.             if ( !gDocWindow )
  448.                 return true;
  449.             break;
  450. #endif
  451.         case kSMDash:
  452.             break;
  453.         default:
  454.             /* Here is where we actually do some spellchecking! */
  455.             if ( !gDocWindow )
  456.                 return true;
  457.             
  458.             DoSpellCheck( theItem - kSMDash );
  459.             
  460.             break;
  461.     }
  462.     return true;
  463. }
  464.     
  465. Boolean DoMouseUp( void )
  466. {
  467.     return true;
  468. }
  469.  
  470. Boolean DoKeyDown( long message, short modifiers )
  471. {
  472.     char        theChar;
  473.     Boolean        result;
  474.     TEHandle    textH;
  475.     short        numLines;
  476.     
  477.     theChar = message & charCodeMask;
  478.     
  479.     if ( modifiers & cmdKey ){
  480.         FixMenuMarks();        /* We need to have the dis/enabling up to date */
  481.         result = DoMenuCommand( MenuKey( theChar ) );
  482.     }else {
  483.         if ( gDocWindow && ( gDocWindow == FrontWindow() )){
  484.             gDocDirty = true;
  485.             textH = (TEHandle)GetWRefCon( gDocWindow );
  486.             
  487.             numLines = (*textH)->nLines;
  488.             TEKey( theChar, textH );
  489.             if ( numLines != (*textH)->nLines ){
  490.                 /* We may need to reset the scroll bar if we changed the number of lines */
  491.                 ShowSelection( textH );
  492.                 SetVertScroll(    gDocWindow, gVertScroll );
  493.             }
  494.         }
  495.         result = true;
  496.     }
  497.         
  498.     return result;
  499. }
  500.  
  501. Boolean DoUpdateEvt( long message )
  502. {
  503.     GrafPtr    curPort;
  504.     
  505.     BeginUpdate( (WindowPtr)message );
  506.     
  507.     if ( (WindowPtr)message == gDocWindow ){
  508.         GetPort( &curPort );
  509.         SetPort( gDocWindow );
  510.         EraseRect( &( thePort->portRect ) );
  511.         TEUpdate( &( thePort->portRect ), (TEHandle)GetWRefCon( (WindowPtr)message ) );
  512.         MyDrawGrowIcon( (WindowPtr)message );
  513.         DrawControls( gDocWindow );
  514.         SetPort( curPort );
  515.     }
  516.  
  517.     EndUpdate( (WindowPtr)message );
  518.     return true;
  519. }
  520.  
  521. void MyDrawGrowIcon( WindowPtr theWindow )
  522. {
  523.     RgnHandle    clipRgn;
  524.     Rect        newClip;
  525.     
  526.     /* This will fudge the DrawGrowIcon routine so we only draw the outline for the
  527.      * vertical scroll bar.  It's easier than writing a custom WDEF.
  528.      * We have to set a new clip region because the update region will mask off some
  529.      * of what we might want to draw.
  530.      *
  531.      * thePort must be the window that is getting the icon drawn in it.
  532.      */
  533.  
  534.     clipRgn = NewRgn();
  535.     if ( !clipRgn )
  536.         return;
  537.     
  538.     GetClip( clipRgn );
  539.     
  540.     newClip.top = theWindow->portRect.top;
  541.     newClip.right = theWindow->portRect.right;
  542.     newClip.bottom = theWindow->portRect.bottom;
  543.     newClip.left = newClip.right - 15;
  544.     
  545.     ClipRect( &newClip );
  546.     
  547.     DrawGrowIcon( theWindow );
  548.  
  549.     SetClip( clipRgn );
  550.     
  551.     return;
  552. }
  553.  
  554. Boolean DoDiskEvt( void )
  555. {
  556.     return true;
  557. }
  558.  
  559. Boolean DoActivateEvt( short modifiers )
  560. {
  561.  
  562.     if ( gDocWindow ){
  563.  
  564.         if ( modifiers & activeFlag ){
  565.             TEActivate( (TEHandle)GetWRefCon( gDocWindow ) );
  566.         } else {
  567.             TEDeactivate( (TEHandle)GetWRefCon( gDocWindow ) );
  568.         }
  569.     }
  570.     return true;
  571. }
  572.  
  573. void GrowDocWindow( WindowPtr theWindow, Point where )
  574. {
  575.     long    newSize;
  576.     short    newWidth;
  577.     short    newHeight;
  578.     GrafPtr    curPort;
  579.     Rect    sizeRect;
  580.     
  581.     SetRect( &sizeRect, 80, 80, 32767, 32767 );
  582.  
  583.     newSize = GrowWindow( theWindow, where, &sizeRect );
  584.     if ( newSize == 0L )
  585.         return;
  586.  
  587.     newWidth = (short) newSize;
  588.     newHeight = (short) ( newSize >> 16 );
  589.     
  590.     GetPort( &curPort );
  591.     SetPort( theWindow );
  592.  
  593.     SizeWindow( theWindow, newWidth, newHeight, true );
  594.  
  595.     ResetWindowParts( theWindow );
  596.  
  597.     SetPort( curPort );
  598.  
  599.     return;
  600. }
  601.  
  602. void ResetWindowParts( WindowPtr theWindow )
  603. {
  604.     GrafPtr    curPort;
  605.  
  606.     /* Resize all of the components of the document window after the window itself
  607.      * has been resized.
  608.      */
  609.  
  610.     GetPort( &curPort );
  611.     SetPort( theWindow );
  612.  
  613.     SetTESize( theWindow );
  614.  
  615.     /* We have to redraw the whole window, since the grow icon, scroll bars, and
  616.      * text rectange have all changed
  617.      */
  618.     
  619.     InvalRect( &( theWindow->portRect ) );
  620.     
  621.     SizeVertScroll();
  622.     SetVertScroll( theWindow, gVertScroll );
  623.     
  624.     SetPort( curPort );
  625.  
  626.     return;
  627. }
  628.  
  629. Boolean DoOSEvt( EventRecord *eventPtr )
  630. {
  631.     Boolean inBackground;
  632.     
  633.     switch ((eventPtr->message >> 24) & 0x0FF) {     /* high byte of message */
  634.         case suspendResumeMessage:              /* suspend/resume is also an activate/deactivate */
  635.             if ( gDocWindow ){
  636.  
  637.                 inBackground = (eventPtr->message & resumeFlag) == 0;
  638.                 if (inBackground) {
  639. #ifdef NEVER        /* Don't use for styled textedit */
  640.                     ZeroScrap();
  641.                     TEToScrap();
  642. #endif
  643.                     if ( gDocWindow ){
  644.                         TEDeactivate( (TEHandle)GetWRefCon( gDocWindow ) );
  645.                     }
  646.                 } else {
  647. #ifdef NEVER        /* Don't use for styled textedit */
  648.                     TEFromScrap();
  649. #endif
  650.                     if ( gDocWindow ){
  651.                         TEActivate( (TEHandle)GetWRefCon( gDocWindow ) );
  652.                     }
  653.                 }
  654.             }
  655.             
  656.         default:
  657.             break;
  658.     }
  659.     return true;
  660. }
  661.  
  662. Boolean DoHighLevelEvent( EventRecord *theEventPtr )
  663. {
  664.     OSErr err;
  665.     
  666.     err = AEProcessAppleEvent( theEventPtr );
  667.  
  668.     if ( err ){
  669.         return true;            /* An error result is OK... */
  670.     }
  671.  
  672.     return true;
  673. }
  674.  
  675. void DoAboutMe( void )
  676. {
  677.     DialogPtr    dlg;
  678.     short        item;
  679.     Handle        h;
  680.     short        kind;
  681.     Rect        r;
  682.     
  683.     dlg = GetNewDialog( kAboutMeID, (Ptr)NULL, (WindowPtr) -1 );
  684.  
  685.     if ( !dlg )
  686.         return;
  687.     
  688.     /* 1.0.2 display the version number from the 'vers' resource -
  689.      * Install a "user item" to draw it in a custom font
  690.      */
  691.  
  692.     GetDItem( dlg, kAVersItem, &kind, &h, &r );
  693.     SetDItem( dlg, kAVersItem, kind, (Handle)AboutVersionProc, &r );
  694.  
  695.     do {
  696.         ModalDialog( (ProcPtr)NULL, &item );
  697.     } while ( item != 1 );
  698.     
  699.     DisposDialog( dlg );
  700.     
  701.     return;
  702. }
  703.  
  704. pascal void AboutVersionProc( DialogPtr dlg, short item )
  705. {
  706.     Handle        h;
  707.     short        kind;
  708.     Rect        r;
  709.     GrafPtr        oldPort;
  710.     VersRecHndl    versH;
  711.     
  712.     /* Draw the version number by getting it from the vers
  713.      * resource.  Saves a lot of time when making a new master disk
  714.      */
  715.          
  716.     versH = (VersRecHndl)GetResource( 'vers', rVersID );
  717.  
  718.     if ( !versH ){
  719.         return;
  720.     }
  721.     
  722.     GetPort( &oldPort );
  723.     SetPort( dlg );
  724.     
  725.     GetDItem( dlg, item, &kind, &h, &r );
  726.     
  727.     MoveTo( r.left, r.bottom );
  728.     
  729.     HLock( versH );
  730.     
  731.     PenNormal();
  732.     TextFont( applFont );
  733.     TextSize( 10 );
  734.     TextFace( 0 );
  735.  
  736.     DrawString( (*versH)->shortVersion );
  737.     
  738.     HUnlock( versH );
  739.     ReleaseResource( versH );
  740.     
  741.     SetPort( oldPort );
  742.  
  743.     return;
  744. }
  745.  
  746. void SetTESize( WindowPtr theWindow )
  747. {
  748.     Rect    txRect;
  749.     TEHandle    hTE;
  750.     short    rectOffset;
  751.     
  752.     GetTERect( &( theWindow->portRect ), &txRect );
  753.     
  754.     hTE = (TEHandle)GetWRefCon( theWindow );
  755.     
  756.     rectOffset = (*hTE)->destRect.top - (*hTE)->viewRect.top;
  757.  
  758.     (*hTE)->viewRect = txRect;
  759.  
  760.     txRect.top += rectOffset;
  761.     txRect.bottom += rectOffset;
  762.  
  763.     (*hTE)->destRect = txRect;
  764.  
  765.     TECalText( hTE );
  766.  
  767.     return;
  768. }
  769.  
  770. void GetTERect( Rect *portRectPtr, Rect *txRectPtr )
  771. {
  772.     /* Return the rect for the textedit field that will fit in the
  773.      * given portRect, allowing for the scroll bar, and a little bit
  774.      * of margin around all the edges.
  775.      */
  776.  
  777.     *txRectPtr = *portRectPtr;
  778.     InsetRect( txRectPtr, 4, 0 );
  779.     
  780.     txRectPtr->right -= 16;
  781.  
  782.     return;
  783. }
  784.  
  785. void DoQuit( void )
  786. {
  787.     if ( gDocWindow )
  788.         DoCloseWindow();
  789.     ExitToShell();
  790.     
  791.     return;
  792. }
  793.  
  794. void DoZoom( WindowPtr theWindow, short deskPart )
  795. {
  796.     Boolean isFront;
  797.     
  798.     if ( FrontWindow() == theWindow )
  799.         isFront = true;
  800.     else
  801.         isFront = false;
  802.  
  803.     ZoomWindow( theWindow, deskPart, isFront );
  804.     
  805.     ResetWindowParts( theWindow );
  806.  
  807.     return;
  808. }
  809.